package com.cf.download.controller;

import com.cf.download.dao.SysFileInfoDao;
import com.cf.download.dto.ResponseCode;
import com.cf.download.entity.IntoParam;
import com.cf.download.entity.SysFileInfo;
import com.cf.download.properties.GlobalProperties;
import com.cf.download.until.R;
import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.util.FileSystemUtils;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.multipart.MultipartFile;

import javax.servlet.http.HttpServletRequest;
import java.io.File;
import java.io.IOException;

/**
 * @Author: YangF
 * @Date: 2020-12-30 12:49
 * @description:
 */
@Api(tags = "文件管理")
@RestController
@RequestMapping(value = "/")
public class DownloadController {
    private final Logger logger = LoggerFactory.getLogger(this.getClass());
    /**
     * 默认大小 50M
     */
    public static final long DEFAULT_MAX_SIZE = 50 * 1024 * 1024;
    @Autowired
    private GlobalProperties globalProperties;
    @Autowired
    private SysFileInfoDao sysFileInfoDao;


    /**
     * 批量文件上传
     * @param files
     * @return
     * @throws Exception
     */
    @PostMapping("/batchUpload1")
    @ResponseBody
    @ApiOperation(value = "批量文件上传")
    public ResponseCode batchUpload(@RequestParam("files") MultipartFile[] files, IntoParam param) throws Exception {
        System.out.println("files---"+files);
        System.out.println("param---"+param);
        if (files == null) {
            return ResponseCode.error("参数为空");
        }
        for (MultipartFile multipartFile : files) {
            upload(multipartFile,param);
        }
        return ResponseCode.success("批量上传成功");
    }


    /**
     * 单文件上传
     * @param file
     * @return
     */
    @PostMapping("/upload1")
    @ApiOperation(value = "单文件上传")
    private ResponseCode upload(@RequestParam("file") MultipartFile file, IntoParam param) throws Exception {
        // 获取文件在服务器上的存储位置
        String serverPath = param.getUrl();
        System.out.println("serverPath---" + serverPath);
        System.out.println("file---"+ file);
        // 获取允许上传的文件扩展名
        String extension = globalProperties.getExtension();

        File filePath = new File(serverPath);
        logger.info("文件保存的路径为：" + filePath);
        if (!filePath.exists() && !filePath.isDirectory()) {
            logger.info("目录不存在，则创建目录：" + filePath);
            filePath.mkdir();
        }

        // 判断文件是否为空
        if (file.isEmpty()) {
            return ResponseCode.error("文件为空");
        }
        //判断文件是否为空文件
        if (file.getSize() <= 0) {
            return ResponseCode.error("文件大小为空，上传失败");
        }

        // 判断文件大小不能大于50M
        if (DEFAULT_MAX_SIZE != -1 && file.getSize() > DEFAULT_MAX_SIZE) {
            return ResponseCode.error("上传的文件不能大于50M");
        }

        // 获取文件名
        String fileName = file.getOriginalFilename();
        System.out.println("filename--"+ fileName);
        // 获取文件扩展名
        String fileExtension = fileName.substring(fileName.lastIndexOf(".")).toLowerCase();
        System.out.println("fileExtension---"+fileExtension);
        // 判断文件扩展名是否正确
        if (!extension.contains(fileExtension)) {
            return ResponseCode.error("文件扩展名不正确");
        }

        SysFileInfo sysFileInfo = new SysFileInfo();
        // 重新生成的文件名
//        String saveFileName = System.currentTimeMillis() + fileExtension;
        // 在指定目录下创建该文件
        File targetFile = new File(filePath, fileName);

        logger.info("将文件保存到指定目录");
        try {
            file.transferTo(targetFile);
        } catch (IOException e) {
            throw new Exception(e.getMessage());
        }

        // 保存数据
        sysFileInfo.setFileName(fileName);
        sysFileInfo.setFilePath(serverPath + "/" + fileName);
        sysFileInfo.setFileSize(file.getSize());

        logger.info("新增文件数据");
        // 新增文件数据
        sysFileInfoDao.save(sysFileInfo);
        return ResponseCode.success("上传成功");
    }




    //------------------------------------------------------------
    /**
     * 删除指定文件夹或文件
     * @param fileName 文件夹或文件路径
     * @return R
     */
    //成功
    private final String filepathDir = "D:/filePath/pdf/";
    @ApiOperation(value = "删除指定文件")
    @GetMapping("/delet")
    @ResponseBody
    public R  deletFile(@RequestParam("fileName") String fileName){
//        FileSystemUtils.deleteRecursively(new File(filepathDir + fileName));
        FileSystemUtils.deleteRecursively(new File( fileName));

        return R.ok(R.SUCCESS,"删除成功",null);
    }


    @GetMapping("/removeFile")
    @ResponseBody
    public R removeFile(@RequestParam("ordName")String ordName ){
        //数据库中删除文件数据
//    myfileService.removeMyFileByOrdName(ordName);
        //打印看一下绝对路径是否有误
        System.out.println(filepathDir);
        //根据文件的路径获取此文件
        File file = new File(filepathDir + ordName);
        //判断此文件是否为空
        if(file!=null){
            //文件不为空，执行删除
            file.delete();
        }else {
            //为空提示错误信息
            return R.error(R.FAILED, "不存在！");
        }
        return R.ok(R.SUCCESS,"删除成功",null);
    }


//文件删除
//cg

    //---------------------
//cg
    @DeleteMapping("/delete")
    @ApiOperation("删除指定文件夹下的某一文件")
    public R delete2(String fileName){
        String f = filepathDir + fileName;
        try {
            delete(f);
            System.out.println("f-----------"+f);
            if (delete(f)){
                return R.ok(R.SUCCESS,"成功",null);
            }
        }catch (Exception ex) {
            ex.printStackTrace();
        }
        return R.ok(R.SUCCESS,"失败",null);

    }


    /**
     * 删除文件，可以是文件或文件夹
     *
     * @param fileName：要删除的文件名
     * @return 删除成功返回true，否则返回false
     */

    public static boolean delete(String fileName) {
        File file = new File(fileName);
        if (!file.exists()) {
            System.out.println("删除文件失败:" + fileName + "不存在！");
            return false;
        } else {
            if (file.isFile())
                return deleteFile(fileName);
            else
                return deleteDirectory(fileName);
        }
    }

    /**
     * 删除单个文件
     *
     * @param fileName：要删除的文件的文件名
     * @return 单个文件删除成功返回true，否则返回false
     */
    public static boolean deleteFile(String fileName) {
        File file = new File(fileName);
        // 如果文件路径所对应的文件存在，并且是一个文件，则直接删除
        if (file.exists() && file.isFile()) {
            if (file.delete()) {
                System.out.println("删除单个文件" + fileName + "成功！");
                return true;
            } else {
                System.out.println("删除单个文件" + fileName + "失败！");
                return false;
            }
        } else {
            System.out.println("删除单个文件失败：" + fileName + "不存在！");
            return false;
        }
    }



    /**
     * 删除目录及目录下的文件
     *
     * @param dir：要删除的目录的文件路径
     * @return 目录删除成功返回true，否则返回false
     */
    public static boolean deleteDirectory(String dir) {
        // 如果dir不以文件分隔符结尾，自动添加文件分隔符
        if (!dir.endsWith(File.separator))
            dir = dir + File.separator;
        File dirFile = new File(dir);
        // 如果dir对应的文件不存在，或者不是一个目录，则退出
        if ((!dirFile.exists()) || (!dirFile.isDirectory())) {
            System.out.println("删除目录失败：" + dir + "不存在！");
            return false;
        }
        boolean flag = true;
        // 删除文件夹中的所有文件包括子目录
        File[] files = dirFile.listFiles();
        for (int i = 0; i < files.length; i++) {
            // 删除子文件
            if (files[i].isFile()) {
                flag = deleteFile(files[i].getAbsolutePath());
                if (!flag)
                    break;
            }
            // 删除子目录
            else if (files[i].isDirectory()) {
                flag = deleteDirectory(files[i].getAbsolutePath());
                if (!flag)
                    break;
            }
        }
        if (!flag) {
            System.out.println("删除目录失败！");
            return false;
        }
        // 删除当前目录
        if (dirFile.delete()) {
            System.out.println("删除目录" + dir + "成功！");
            return true;
        } else {
            return false;
        }
    }


////    "删除文件夹"
//    public static void delFolder(String folderPath) {
//        try {
//            delAllFile(folderPath); // 删除完里面所有内容
//            String filePath = folderPath;
//            filePath = filePath.toString();
//            java.io.File myFilePath = new java.io.File(filePath);
//            myFilePath.delete(); // 删除空文件夹
//        } catch (Exception e) {
//            e.printStackTrace();
//        }
//    }
//
//    // 删除指定文件夹下所有文件
//// param path 文件夹完整绝对路径
//    public static boolean delAllFile(String path) {
//        boolean flag = false;
//        File file = new File(path);
//        if (!file.exists()) {
//            return flag;
//        }
//        if (!file.isDirectory()) {
//            return flag;
//        }
//        String[] tempList = file.list();
//        File temp = null;
//        for (int i = 0; i < tempList.length; i++) {
//            if (path.endsWith(File.separator)) {
//                temp = new File(path + tempList[i]);
//            } else {
//                temp = new File(path + File.separator + tempList[i]);
//            }
//            if (temp.isFile()) {
//                temp.delete();
//            }
//            if (temp.isDirectory()) {
//                delAllFile(path + "/" + tempList[i]);// 先删除文件夹里面的文件
//                delFolder(path + "/" + tempList[i]);// 再删除空文件夹
//                flag = true;
//            }
//        }
//        return flag;
//    }
}

